#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
物流运费计算模块 - 集成百度地图API
"""
import sys
import os

# 添加路径以支持导入
current_dir = os.path.dirname(os.path.abspath(__file__))
new_models_dir = os.path.join(os.path.dirname(current_dir), "new_models")
map_code_dir = os.path.join(new_models_dir, "地图坐标获取", "code")

if new_models_dir not in sys.path:
    sys.path.insert(0, new_models_dir)
if map_code_dir not in sys.path:
    sys.path.insert(0, map_code_dir)

try:
    from akget import keyget
    from calculate import get_lng_lat, get_road_distance
except ImportError as e:
    print(f"警告：无法导入百度地图API模块: {e}")
    print("将使用模拟数据")
    keyget = None
    get_lng_lat = None
    get_road_distance = None


# 默认发货地址（仓库地址）- 可以根据实际情况修改
DEFAULT_WAREHOUSE_ADDRESS = "北京市朝阳区三里屯街道工体北路8号院"  # 示例地址


def calculate_shipping_fee(distance_km):
    """
    根据距离计算运费
    
    运费规则：
    - 10km以内：统一10元
    - 大于10km：每200km加8元
    
    参数:
        distance_km: 距离（公里）
        
    返回:
        运费（元）
    """
    if distance_km <= 10:
        return 10.0
    else:
        # 计算超出10km的部分
        excess_km = distance_km - 10
        # 每200km加8元
        additional_fee = (excess_km / 200) * 8
        return round(10.0 + additional_fee, 2)


def calculate_estimated_delivery_time(distance_km=None, duration_h=None):
    """
    计算预计送达时间（基于距离和耗时）
    
    逻辑：
    1. 如果提供了实际距离和耗时，基于实际物流时间计算
    2. 考虑订单处理时间（6-24小时）
    3. 考虑物流配送时间（基于百度API返回的驾车耗时）
    4. 如果API失败，使用基于距离的估算
    
    参数:
        distance_km: 距离（公里）
        duration_h: 驾车耗时（小时），来自百度API
        
    返回:
        预计送达时间戳（Unix时间戳）
    """
    from datetime import datetime, timedelta
    
    # 基础处理时间（订单处理、打包等）：6-24小时，根据距离调整
    if distance_km is None:
        # 没有距离信息，使用默认3天
        processing_hours = 24
    elif distance_km <= 10:
        # 短距离：快速处理（6小时）
        processing_hours = 6
    elif distance_km <= 100:
        # 中距离：正常处理（12小时）
        processing_hours = 12
    else:
        # 长距离：完整处理（24小时）
        processing_hours = 24
    
    # 物流配送时间
    if duration_h is not None:
        # 使用百度API返回的实际驾车耗时
        # 实际物流配送时间通常是驾车时间的1.5-2倍（考虑中转、装卸等）
        if distance_km and distance_km <= 10:
            # 同城配送：1.2倍驾车时间
            delivery_hours = duration_h * 1.2
        elif distance_km and distance_km <= 100:
            # 短途配送：1.5倍驾车时间
            delivery_hours = duration_h * 1.5
        else:
            # 长途配送：2倍驾车时间（考虑中转站）
            delivery_hours = duration_h * 2.0
    elif distance_km is not None:
        # 没有API耗时数据，基于距离估算
        # 假设平均物流速度：50km/h（考虑中转、装卸）
        delivery_hours = distance_km / 50.0
    else:
        # 完全没有数据，使用默认值（3天）
        delivery_hours = 72
    
    # 总时间 = 处理时间 + 配送时间
    total_hours = processing_hours + delivery_hours
    
    # 加上一些缓冲时间（确保按时送达）
    buffer_hours = max(6, total_hours * 0.1)  # 至少6小时缓冲，或10%的额外时间
    final_hours = total_hours + buffer_hours
    
    # 计算预计送达时间
    estimated_delivery = datetime.now() + timedelta(hours=final_hours)
    
    return estimated_delivery.timestamp()


def get_distance_between_addresses(origin_address, dest_address):
    """
    获取两个地址之间的实际道路距离
    
    参数:
        origin_address: 起始地址（发货地址）
        dest_address: 目标地址（收货地址）
        
    返回:
        字典包含:
        - distance_km: 距离（公里）
        - duration_h: 预计耗时（小时）
        - success: 是否成功
        - error: 错误信息（如果有）
    """
    try:
        # 获取API密钥
        if keyget is None:
            return {
                "success": False,
                "error": "百度地图API模块未导入",
                "distance_km": None,
                "duration_h": None
            }
        
        ak = keyget()
        if not ak:
            return {
                "success": False,
                "error": "百度地图API密钥未配置",
                "distance_km": None,
                "duration_h": None
            }
        
        # 获取起始地址坐标
        origin_coords = get_lng_lat(origin_address, ak)
        if origin_coords is None:
            return {
                "success": False,
                "error": f"无法获取起始地址坐标: {origin_address}",
                "distance_km": None,
                "duration_h": None
            }
        
        origin_lng, origin_lat = origin_coords
        
        # 获取目标地址坐标
        dest_coords = get_lng_lat(dest_address, ak)
        if dest_coords is None:
            return {
                "success": False,
                "error": f"无法获取目标地址坐标: {dest_address}",
                "distance_km": None,
                "duration_h": None
            }
        
        dest_lng, dest_lat = dest_coords
        
        # 获取道路距离
        road_info = get_road_distance(origin_lng, origin_lat, dest_lng, dest_lat, ak)
        
        return {
            "success": True,
            "distance_km": road_info["distance_km"],
            "duration_h": road_info["duration_h"],
            "error": None
        }
        
    except Exception as e:
        return {
            "success": False,
            "error": str(e),
            "distance_km": None,
            "duration_h": None
        }


def calculate_shipping_fee_from_addresses(warehouse_address, delivery_address, use_api=True):
    """
    根据仓库地址和收货地址计算运费
    
    参数:
        warehouse_address: 仓库地址（发货地址）
        delivery_address: 收货地址
        use_api: 是否使用百度API（如果False，使用默认运费）
        
    返回:
        字典包含:
        - shipping_fee: 运费（元）
        - distance_km: 距离（公里）
        - duration_h: 预计耗时（小时）
        - success: 是否成功
        - error: 错误信息（如果有）
    """
    if not use_api:
        # 如果不使用API，返回默认运费
        return {
            "success": True,
            "shipping_fee": 15.0,  # 默认运费
            "distance_km": None,
            "duration_h": None,
            "error": None
        }
    
    # 获取距离
    distance_result = get_distance_between_addresses(warehouse_address, delivery_address)
    
    if not distance_result["success"]:
        # 如果API调用失败，返回默认运费
        return {
            "success": False,
            "shipping_fee": 15.0,  # 失败时使用默认运费
            "distance_km": None,
            "duration_h": None,
            "error": distance_result["error"]
        }
    
    # 根据距离计算运费
    distance_km = distance_result["distance_km"]
    shipping_fee = calculate_shipping_fee(distance_km)
    
    return {
        "success": True,
        "shipping_fee": shipping_fee,
        "distance_km": distance_km,
        "duration_h": distance_result["duration_h"],
        "error": None
    }


# 测试函数
if __name__ == "__main__":
    print("===== 物流运费计算测试 =====\n")
    
    # 测试距离计算
    test_distances = [5, 10, 50, 200, 500, 1000]
    print("运费计算测试:")
    for distance in test_distances:
        fee = calculate_shipping_fee(distance)
        print(f"距离 {distance}km -> 运费 ¥{fee}")
    
    print("\n" + "="*50)
    
    # 测试地址距离计算（需要有效的百度API密钥）
    warehouse = DEFAULT_WAREHOUSE_ADDRESS
    test_address = "北京市海淀区中关村大街1号"
    
    print(f"\n地址距离测试:")
    print(f"仓库地址: {warehouse}")
    print(f"收货地址: {test_address}")
    
    result = calculate_shipping_fee_from_addresses(warehouse, test_address, use_api=True)
    
    if result["success"]:
        print(f"距离: {result['distance_km']}km")
        print(f"预计耗时: {result['duration_h']}小时")
        print(f"运费: ¥{result['shipping_fee']}")
    else:
        print(f"计算失败: {result['error']}")
        print(f"使用默认运费: ¥{result['shipping_fee']}")

